import type { Question } from '@/types/exam';

/**
 * Java基础语法题目（初级10道 + 中级10道 + 高级10道）
 */
export const basicQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 1001,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个关键字用于声明常量？',
		options: [
			{ key: 'A', text: 'const' },
			{ key: 'B', text: 'final' },
			{ key: 'C', text: 'static' },
			{ key: 'D', text: 'constant' }
		],
		answer: ['B'],
		explanation: 'final关键字用于声明常量。被final修饰的变量，其值一旦被初始化就不能再被修改。'
	},
	{
		id: 1002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中byte类型的取值范围是？',
		options: [
			{ key: 'A', text: '-128 ~ 127' },
			{ key: 'B', text: '0 ~ 255' },
			{ key: 'C', text: '-256 ~ 255' },
			{ key: 'D', text: '0 ~ 127' }
		],
		answer: ['A'],
		explanation: 'byte是8位有符号整数，取值范围是-128到127（-2^7到2^7-1）。'
	},
	{
		id: 1003,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中int类型占用4个字节。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'int类型占用4个字节（32位），取值范围是-2^31到2^31-1。'
	},
	{
		id: 1004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个是合法的标识符？',
		options: [
			{ key: 'A', text: '2variable' },
			{ key: 'B', text: '_variable' },
			{ key: 'C', text: 'class' },
			{ key: 'D', text: 'variable-name' }
		],
		answer: ['B'],
		explanation: '标识符不能以数字开头，不能是关键字（class），不能包含连字符。以下划线开头的标识符是合法的。'
	},
	{
		id: 1005,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个是基本数据类型？',
		options: [
			{ key: 'A', text: 'String' },
			{ key: 'B', text: 'Integer' },
			{ key: 'C', text: 'char' },
			{ key: 'D', text: 'Array' }
		],
		answer: ['C'],
		explanation: 'char是Java的8种基本数据类型之一。String、Integer、Array都是引用类型。'
	},
	{
		id: 1006,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，boolean类型只有true和false两个值。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'boolean类型只有true和false两个值，不能像C语言那样用0和1表示。'
	},
	{
		id: 1007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个运算符用于取模运算？',
		options: [
			{ key: 'A', text: '&' },
			{ key: 'B', text: '%' },
			{ key: 'C', text: '/' },
			{ key: 'D', text: '*' }
		],
		answer: ['B'],
		explanation: '%运算符用于取模运算（求余数），例如 10 % 3 = 1。'
	},
	{
		id: 1008,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个关键字用于声明类？',
		options: [
			{ key: 'A', text: 'class' },
			{ key: 'B', text: 'Class' },
			{ key: 'C', text: 'type' },
			{ key: 'D', text: 'struct' }
		],
		answer: ['A'],
		explanation: 'class关键字用于声明类，这是Java面向对象编程的基础。'
	},
	{
		id: 1009,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，方法必须定义返回值类型，如果没有返回值，使用void。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'Java中方法必须声明返回值类型，如果没有返回值，使用void关键字。'
	},
	{
		id: 1010,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java基础语法',
		question: 'Java中，以下哪个用于声明数组？',
		options: [
			{ key: 'A', text: 'int[] arr' },
			{ key: 'B', text: 'int arr[]' },
			{ key: 'C', text: 'A和B都可以' },
			{ key: 'D', text: '只能使用Array类型' }
		],
		answer: ['C'],
		explanation: 'Java中数组声明可以使用int[] arr或int arr[]两种方式，推荐使用int[] arr。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 1011,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: '以下哪些是Java的基本数据类型？',
		options: [
			{ key: 'A', text: 'int' },
			{ key: 'B', text: 'String' },
			{ key: 'C', text: 'boolean' },
			{ key: 'D', text: 'float' }
		],
		answer: ['A', 'C', 'D'],
		explanation: 'Java有8种基本数据类型：byte、short、int、long、float、double、char、boolean。String是引用类型。'
	},
	{
		id: 1012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于类型转换的说法，正确的是？',
		options: [
			{ key: 'A', text: '所有类型都可以自动转换' },
			{ key: 'B', text: '小类型可以自动转换为大类型' },
			{ key: 'C', text: '大类型可以自动转换为小类型' },
			{ key: 'D', text: '基本类型和包装类型不能转换' }
		],
		answer: ['B'],
		explanation: 'Java中，小类型（如int）可以自动转换为大类型（如long），但大类型转小类型需要强制转换，可能丢失精度。'
	},
	{
		id: 1013,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下哪个关于switch语句的说法是正确的？',
		options: [
			{ key: 'A', text: 'switch只能用于整数类型' },
			{ key: 'B', text: 'switch可以用于String（Java 7+）' },
			{ key: 'C', text: 'switch必须有default分支' },
			{ key: 'D', text: 'switch不能使用break' }
		],
		answer: ['B'],
		explanation: '从Java 7开始，switch语句支持String类型。switch可以用于byte、short、int、char、enum和String，default分支是可选的。'
	},
	{
		id: 1014,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于循环语句的说法，错误的是？',
		options: [
			{ key: 'A', text: 'for循环可以嵌套使用' },
			{ key: 'B', text: 'while循环先判断条件' },
			{ key: 'C', text: 'do-while至少执行一次' },
			{ key: 'D', text: '循环语句不能使用break' }
		],
		answer: ['D'],
		explanation: '循环语句可以使用break跳出循环，使用continue跳过本次循环。for、while、do-while都可以嵌套使用。'
	},
	{
		id: 1015,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于操作符优先级的说法，正确的是？',
		options: [
			{ key: 'A', text: '算术运算符优先级高于逻辑运算符' },
			{ key: 'B', text: '赋值运算符优先级最高' },
			{ key: 'C', text: '所有运算符优先级相同' },
			{ key: 'D', text: '逻辑运算符优先级高于算术运算符' }
		],
		answer: ['A'],
		explanation: '运算符优先级：括号 > 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符。'
	},
	{
		id: 1016,
		techId: 'java',
		type: 'judge',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，可以使用==比较两个String对象的内容。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['B'],
		explanation: '==比较的是引用地址，不是内容。应该使用equals()方法比较String的内容。'
	},
	{
		id: 1017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于包装类的说法，正确的是？',
		options: [
			{ key: 'A', text: '包装类和基本类型完全等价' },
			{ key: 'B', text: '包装类支持自动装箱和拆箱' },
			{ key: 'C', text: '包装类不能为null' },
			{ key: 'D', text: '包装类性能优于基本类型' }
		],
		answer: ['B'],
		explanation: 'Java 5+支持自动装箱（基本类型转包装类）和拆箱（包装类转基本类型）。包装类可以为null，性能略低于基本类型。'
	},
	{
		id: 1018,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于变量的作用域，说法正确的是？',
		options: [
			{ key: 'A', text: '局部变量可以在方法外访问' },
			{ key: 'B', text: '成员变量可以在类内任何地方访问' },
			{ key: 'C', text: '静态变量只能通过实例访问' },
			{ key: 'D', text: '所有变量作用域相同' }
		],
		answer: ['B'],
		explanation: '成员变量可以在类的任何地方访问；局部变量只能在声明的方法内访问；静态变量可以通过类名直接访问。'
	},
	{
		id: 1019,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: '以下哪些是Java的访问修饰符？',
		options: [
			{ key: 'A', text: 'public' },
			{ key: 'B', text: 'private' },
			{ key: 'C', text: 'protected' },
			{ key: 'D', text: 'default' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java有4种访问修饰符：public（公共）、protected（受保护）、private（私有）、default（默认，包内可见）。'
	},
	{
		id: 1020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java基础语法',
		question: 'Java中，以下关于构造方法的说法，错误的是？',
		options: [
			{ key: 'A', text: '构造方法名必须与类名相同' },
			{ key: 'B', text: '构造方法可以有返回值' },
			{ key: 'C', text: '构造方法可以重载' },
			{ key: 'D', text: '如果没有定义构造方法，编译器会提供默认构造方法' }
		],
		answer: ['B'],
		explanation: '构造方法没有返回值，也不能声明void。构造方法名必须与类名相同，可以重载，如果没有定义会提供默认无参构造方法。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 1021,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下代码的输出结果是？\nint a = 5;\nint b = a++;\nSystem.out.println(a + "," + b);',
		options: [
			{ key: 'A', text: '5,5' },
			{ key: 'B', text: '6,5' },
			{ key: 'C', text: '6,6' },
			{ key: 'D', text: '5,6' }
		],
		answer: ['B'],
		explanation: 'a++是后置递增，先赋值后自增。b = a++，先将a的值5赋给b，然后a自增为6。所以输出6,5。'
	},
	{
		id: 1022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于泛型的说法，正确的是？',
		options: [
			{ key: 'A', text: '泛型只在编译时有效，运行时会被擦除' },
			{ key: 'B', text: '泛型可以用于基本类型' },
			{ key: 'C', text: 'List<String>和List<Object>是兼容的' },
			{ key: 'D', text: '泛型不能使用通配符' }
		],
		answer: ['A'],
		explanation: 'Java泛型使用类型擦除，编译时检查类型，运行时擦除。泛型不能用于基本类型，List<String>和List<Object>不兼容，可以使用通配符？。'
	},
	{
		id: 1023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于反射的说法，错误的是？',
		options: [
			{ key: 'A', text: '反射可以在运行时获取类的信息' },
			{ key: 'B', text: '反射可以动态创建对象' },
			{ key: 'C', text: '反射性能优于直接调用' },
			{ key: 'D', text: '反射可以访问私有成员' }
		],
		answer: ['C'],
		explanation: '反射性能低于直接调用，因为需要在运行时解析类的信息。反射可以获取类信息、创建对象、调用方法，甚至可以访问私有成员（通过setAccessible）。'
	},
	{
		id: 1024,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: '以下哪些是Java的注解（Annotation）？',
		options: [
			{ key: 'A', text: '@Override' },
			{ key: 'B', text: '@Deprecated' },
			{ key: 'C', text: '@SuppressWarnings' },
			{ key: 'D', text: '@FunctionalInterface' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: '这些都是Java内置注解：@Override（重写方法）、@Deprecated（已废弃）、@SuppressWarnings（抑制警告）、@FunctionalInterface（函数式接口）。'
	},
	{
		id: 1025,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于枚举（enum）的说法，正确的是？',
		options: [
			{ key: 'A', text: '枚举不能实现接口' },
			{ key: 'B', text: '枚举可以有构造函数' },
			{ key: 'C', text: '枚举值不能有方法' },
			{ key: 'D', text: '枚举不能用于switch语句' }
		],
		answer: ['B'],
		explanation: '枚举可以有构造函数、方法、实现接口。枚举值可以有自己的方法，可以用于switch语句。枚举是特殊的类。'
	},
	{
		id: 1026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于可变参数（varargs）的说法，正确的是？',
		options: [
			{ key: 'A', text: '可变参数只能有一个' },
			{ key: 'B', text: '可变参数必须是最后一个参数' },
			{ key: 'C', text: '可变参数不能与方法重载配合使用' },
			{ key: 'D', text: '可变参数性能优于数组' }
		],
		answer: ['B'],
		explanation: '可变参数必须放在参数列表的最后，一个方法只能有一个可变参数。可变参数本质是数组，性能相同。'
	},
	{
		id: 1027,
		techId: 'java',
		type: 'judge',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，可以使用instanceof判断一个对象是否为某个类的实例。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'instanceof运算符用于判断对象是否为某个类或其子类的实例。例如：obj instanceof String。'
	},
	{
		id: 1028,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于内部类的说法，错误的是？',
		options: [
			{ key: 'A', text: '内部类可以访问外部类的私有成员' },
			{ key: 'B', text: '静态内部类不能访问外部类的非静态成员' },
			{ key: 'C', text: '局部内部类不能访问方法的局部变量（Java 8+可以）' },
			{ key: 'D', text: '匿名内部类必须有类名' }
		],
		answer: ['D'],
		explanation: '匿名内部类没有类名，用于创建一次性使用的类。Java 8+允许局部内部类和匿名内部类访问final或effectively final的局部变量。'
	},
	{
		id: 1029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: 'Java中，以下关于类型推断的说法，正确的是？',
		options: [
			{ key: 'A', text: 'Java不支持类型推断' },
			{ key: 'B', text: 'Java 7+支持菱形运算符<>' },
			{ key: 'C', text: 'Java 10+支持var关键字' },
			{ key: 'D', text: '类型推断只能用于局部变量' }
		],
		answer: ['C'],
		explanation: 'Java 7引入菱形运算符（List<String> list = new ArrayList<>()），Java 10引入var关键字进行局部变量类型推断。'
	},
	{
		id: 1030,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java基础语法',
		question: '以下哪些是Java的引用类型？',
		options: [
			{ key: 'A', text: 'String' },
			{ key: 'B', text: '数组' },
			{ key: 'C', text: '接口' },
			{ key: 'D', text: '枚举' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java中所有非基本类型都是引用类型，包括类、接口、数组、枚举等。引用类型变量存储的是对象的引用地址。'
	}
];

